home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / Dots & Pixels / sources / macutilities.cp < prev    next >
Text File  |  1995-09-29  |  5KB  |  200 lines
  1. #if defined( __SC__)
  2.     #include <pascal.h>
  3. #endif
  4.  
  5. #include <Types.h>
  6. #include <SegLoad.h>
  7. #include <Files.h>
  8. #include <Resources.h>
  9. #include <Memory.h>
  10. #include <Devices.h>
  11. #include <Palettes.h>
  12. #include <Timer.h>
  13.  
  14. #include "general.h"
  15. #include "macutilities.h"
  16. //
  17. // 940207: 'framerate_of_main_monitor()' doesn't seem to work any more.
  18. // I don't have time to delve deep into it, so I simply replace it by
  19. // a version which is not 100% guaranteed to work.
  20. //
  21. // 940209: The problem seemed to be related to a damaged copy of TPM or
  22. // one of its translators. After reinstalling SC++ 6.0.1 from scratch
  23. // everything seems to work again (take that back; the crashes reappeared
  24. // within a day) (940216: It seems to work perfectly now)
  25. //
  26. // 940122: framerate_of_main_monitor has been moved to 'vretrace.cp'
  27. //
  28. void set_settingsfile( char *settingsfile, const OSType creator)
  29. {
  30.     //
  31.     // 930408: first check whether a parameter was passed to this file.
  32.     //
  33.     // 950309: CountAppFiles is unsupported in the Universal Interfaces
  34.     // The new 'SegLoad.h' states:
  35.     //
  36.     //    CountAppFiles, GetAppFiles, ClrAppFiles, GetAppParms, and 
  37.     //    getappparms are obsolete. They are still supported for 68K 
  38.     //    apps (if OBSOLETE is defined), but they are not supported 
  39.     //    for PowerPC apps. Use AppleEvents to determine which files
  40.     //    are to be opened or printed from the Finder.
  41.     //
  42.     // We hack around this. This implies that our no-nonsense interface
  43.     // to the experiments doesn't work on a PPC!!
  44.     //
  45. #ifndef __MWERKS__
  46.     short message;
  47.     short count;
  48.  
  49.     CountAppFiles( &message, &count);
  50.  
  51.     if( count == 0)
  52.     {
  53. #endif
  54.         //
  55.         // check for the existence of the options file first. If it doesn't exist it can be
  56.         // recreated from 'TEXT' resource #128.
  57.         //
  58.         CtoPstr( settingsfile);
  59.         OSErr foutje = Create( (const unsigned char *)settingsfile, 0, creator, 'TEXT');
  60.     
  61.         if( foutje == noErr)
  62.         {
  63.             short filerefno;
  64.             foutje = FSOpen( (const unsigned char *)settingsfile, 0, &filerefno);
  65.             
  66.             if( foutje == noErr)
  67.             {
  68.                 Handle default_text = GetResource( 'TEXT', 128);
  69.                 if( default_text == 0)
  70.                 {
  71.                     report_error_and_exit( "TEXT resource 128 could not be found");
  72.                 }
  73.                 long numbytes = GetHandleSize( default_text);
  74.                 HLock( default_text);
  75.                 foutje = FSWrite( filerefno, &numbytes, StripAddress( *default_text));
  76.                 ReleaseResource( default_text);
  77.                 
  78.                 if( foutje != noErr)
  79.                 {
  80.                     report_error_and_exit( "error writing default parameter file");
  81.                 }
  82.                 foutje = FSClose( filerefno);
  83.                 if( foutje != noErr)
  84.                 {
  85.                     report_error_and_exit( "error closing default parameter file");
  86.                 }
  87.             }
  88.         }
  89.         //
  90.         // Convert back to C string; the main app expects it to be unchanged
  91.         //
  92.         PtoCstr( (unsigned char *)settingsfile);
  93. #ifndef __MWERKS__
  94.     } else {
  95.         if( count == 1)
  96.         {
  97.             AppFile thefile;
  98.             GetAppFiles( 1, &thefile);
  99.             ClrAppFiles( 1);
  100.             
  101.             if( thefile.fType != 'TEXT')
  102.             {
  103.                 report_error_and_exit( "Sorry, can only open TEXT files");
  104.             }
  105.             SetVol( 0, thefile.vRefNum);
  106.             //
  107.             // copy Pascal string in 'thefile.fName' as C string to 'settingsfile':
  108.             //
  109.             const int numbytes = thefile.fName[ 0];
  110.             
  111.             for( int i = 0; i < numbytes; i++)
  112.             {
  113.                 settingsfile[ i] = thefile.fName[ i + 1];
  114.             }
  115.             settingsfile[ numbytes] = 0;
  116.         } else {
  117.             //
  118.             // More than one file was passed to the application: we don't support that.
  119.             //
  120.             report_error_and_exit(
  121.                 "Sorry, only one file at a time can be passed to this application"
  122.             );
  123.         }
  124.     }
  125. #endif
  126. }
  127.  
  128. int TwoBitColorMode( const GDHandle thedevice)
  129. {
  130.     int result = 0;
  131.     
  132.     const int current_type = (**thedevice).gdType;
  133.     
  134.     if( current_type == clutType)
  135.     {
  136.         //
  137.         // bit #  value   contents:
  138.         //   0    0x0001  set if device supports color
  139.         //  13    0x2000  set if device is a screen device
  140.         //  15    0x8000  set if device is active
  141.         //
  142.         // check for 2-bit color mode
  143.         //
  144.         result = HasDepth( thedevice, 2, 0x0001, 0x0001);
  145.     }
  146.     return result;
  147. }
  148.  
  149. int GetIxDevice( const int monitorno, GDHandle &theGDevice, short &themode, short bitDepth)
  150. {
  151.     theGDevice = GetDeviceList();
  152.     themode    = 0;
  153.     
  154.     int current_index = 1;
  155.     
  156.     while( (theGDevice != 0) && (current_index < monitorno))
  157.     {
  158.         theGDevice = GetNextDevice( theGDevice);
  159.         current_index += 1;
  160.     }
  161.     if( theGDevice != 0)
  162.     {
  163.         //
  164.         // monitor exists; check its characteristics
  165.         //
  166.         const int current_type = (**theGDevice).gdType;
  167.         
  168.         if( current_type == clutType)
  169.         {
  170.             //
  171.             // bit #  value   contents:
  172.             //   0    0x0001  set if device supports color
  173.             //  13    0x2000  set if device is a screen device
  174.             //  15    0x8000  set if device is active
  175.             //   
  176.             // check for depth
  177.             //
  178.             themode = HasDepth( theGDevice, bitDepth, 0x0001, 0x0001);
  179.         }
  180.     } else {
  181.         //
  182.         // monitor specified doesn't exist
  183.         //
  184.     }
  185.     return( themode != 0);
  186. }
  187.  
  188. void load_clut( const int resno)
  189. {
  190.     CTabHandle clutHandle = (CTabHandle)GetResource( 'clut', resno);
  191.     if( clutHandle != 0L)
  192.     {
  193.         HLock( (Handle)clutHandle);
  194.             const short numEntries_minus_1 = (**clutHandle).ctSize;
  195.             SetEntries( 0, numEntries_minus_1, (**clutHandle).ctTable);
  196.         HUnlock( (Handle)clutHandle);
  197.     }
  198.     ReleaseResource( (Handle)clutHandle);
  199. }
  200.